﻿#define _CRT_SECURE_NO_WARNINGS 1

#if 0
#include <iostream>
#include <type_traits>

// 定义一个结构体
struct MyStruct {
    char a;     // 1 byte
    int b;      // 4 bytes
    double c;   // 8 bytes
    short d;    // 2 bytes
};

int main() {
    // 打印每个成员的偏移量
    std::cout << "Offset of a: " << offsetof(MyStruct, a) << std::endl;
    std::cout << "Offset of b: " << offsetof(MyStruct, b) << std::endl;
    std::cout << "Offset of c: " << offsetof(MyStruct, c) << std::endl;
    std::cout << "Offset of d: " << offsetof(MyStruct, d) << std::endl;

    // 打印每个成员的对齐要求
    std::cout << "Alignment of char: " << alignof(char) << std::endl;
    std::cout << "Alignment of int: " << alignof(int) << std::endl;
    std::cout << "Alignment of double: " << alignof(double) << std::endl;
    std::cout << "Alignment of short: " << alignof(short) << std::endl;

    // 打印结构体的大小和对齐要求
    std::cout << "Size of MyStruct: " << sizeof(MyStruct) << std::endl;
    std::cout << "Alignment of MyStruct: " << alignof(MyStruct) << std::endl;

    // 解释内存布局
    std::cout << "\nMemory Layout Explanation:\n";
    std::cout << "a (1 byte) at offset 0\n";
    std::cout << "Padding (3 bytes) to align b to 4-byte boundary\n";
    std::cout << "b (4 bytes) at offset 4\n";
    std::cout << "Padding (4 bytes) to align c to 8-byte boundary\n";
    std::cout << "c (8 bytes) at offset 8\n";
    std::cout << "d (2 bytes) at offset 16\n";
    std::cout << "Padding (6 bytes) to make the total size a multiple of the largest alignment (8 bytes)\n";

    return 0;
}

#endif

#if 0
#include<iostream>
using namespace std;
class Date
{
public:
    //// 1.无参构造函数

    //Date()
    //{
    //    _year = 1;
    //    _month = 1;
    //    _day = 1;
    //}
     //2.全缺省构造函数

   Date(int year = 1, int month = 1, int day = 1)
   {
   _year = year;
   _month = month;
   _day = day;
   }
     //3.带参构造函数

    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
   
    void Print()
    {
        cout << _year << "/" << _month << "/" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    // 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉

    // 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤

    Date d1; // 调⽤默认构造函数

    Date d2(2025, 1, 1); // 调⽤带参的构造函数

    // 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法

    // 区分这⾥是函数声明还是实例化对象

    // warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)
    Date d3();
    d1.Print();
    d2.Print();
    return 0;
}


#endif

#if 0

#include <iostream>  
#include <cstring>  

class MyClass {
private:
    char* data;

public:
    // 构造函数  
    MyClass(const char* str) {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }

    // 拷贝构造函数（默认实现为浅拷贝）  
    MyClass(const MyClass& other) {
        data = other.data; // 浅拷贝：复制指针值  
    }

    // 深拷贝的拷贝构造函数  
    MyClass deepCopyConstructor(const MyClass& other) {
        MyClass newObject;
        newObject.data = new char[strlen(other.data) + 1];
        strcpy(newObject.data, other.data);
        return newObject;
    }

    // 析构函数  
    ~MyClass() {
        delete[] data;
    }

    // 打印数据  
    void print() const {
        std::cout << data << std::endl;
    }
};

int main() {
    MyClass obj1("Hello, World!");
    std::cout << "Original object: ";
    obj1.print();

    // 使用浅拷贝  
    MyClass obj2 = obj1; // 调用默认的拷贝构造函数  
    std::cout << "Shallow copy object: ";
    obj2.print();

    // 修改浅拷贝对象的指针指向的内存内容  
    strcpy(obj2.data, "Shallow Modified");
    std::cout << "After modifying shallow copy: ";
    obj1.print(); // 原对象也被修改  

    // 使用深拷贝  
    MyClass obj3 = obj1.deepCopyConstructor(obj1); // 调用深拷贝的拷贝构造函数  
    std::cout << "Deep copy object: ";
    obj3.print();

    // 修改深拷贝对象的指针指向的内存内容  
    strcpy(obj3.data, "Deep Modified");
    std::cout << "After modifying deep copy: ";
    obj1.print(); // 原对象未被修改  

    return 0;
}

#endif

#if 0
//浅拷贝
#include <iostream>
using namespace std;

class ShallowCopy {
private:
    int* data;
public:
    ShallowCopy(int d) : data(new int(d)) {} // 构造函数
    ~ShallowCopy() { delete data; } // 析构函数
    void setData(int d) { *data = d; }
    int getData() const { return *data; }

    // 默认复制构造函数（浅拷贝）
    ShallowCopy(const ShallowCopy& source) : data(source.data) {}
};

int main() {
    ShallowCopy obj1(10);
    ShallowCopy obj2 = obj1; // 使用默认复制构造函数

    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl;

    obj1.setData(20); // 修改 obj1 的数据

    cout << "After modifying obj1" << endl;
    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl; // obj2 数据也被修改了

    return 0;
}

#endif

#if 0
//深拷贝
//深拷贝
#include <iostream>
using namespace std;

class DeepCopy {
private:
    int* data;
public:
    DeepCopy(int d) : data(new int(d)) {} // 构造函数
    ~DeepCopy() { delete data; } // 析构函数
    void setData(int d) { *data = d; }
    int getData() const { return *data; }

    // 自定义复制构造函数（深拷贝）
    DeepCopy(const DeepCopy& source) : data(new int(*source.data)) {}
};

int main() {
    DeepCopy obj1(10);
    DeepCopy obj2 = obj1; // 使用自定义复制构造函数

    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl;

    obj1.setData(20); // 修改 obj1 的数据

    cout << "After modifying obj1" << endl;
    cout << "obj1 data: " << obj1.getData() << endl;
    cout << "obj2 data: " << obj2.getData() << endl; // obj2 数据没有变化

    return 0;
}

#endif

#if 0
//赋值运算符重载

#include <iostream>  
#include <cstring>  // For std::strcpy  

class MyClass {
private:
    char* data;
    size_t size;

public:
    //构造
    MyClass(const char* str = "") {
        size = std::strlen(str) + 1;  // +1 for null terminator  
        data = new char[size];
        std::strcpy(data, str);
    }

    // 拷贝构造
    MyClass(const MyClass& other) {
        size = other.size;
        data = new char[size];
        std::strcpy(data, other.data);
    }

    // 赋值运算符重载
    MyClass& operator=(const MyClass& other) {
        // Check for self-assignment  
        if (this == &other) {
            return *this;
        }

        // Clean up existing resources  
        delete[] data;

        // Allocate new resources and copy data  
        size = other.size;
        data = new char[size];
        std::strcpy(data, other.data);

        return *this;
    }

    //析构
    ~MyClass() {
        delete[] data;
    }

    // 打印数据  
    void display() const {
        std::cout << data << std::endl;
    }
};

int main() {
    MyClass obj1("Hello");
    MyClass obj2("World");

    obj1.display();  // Output: Hello  
    obj2.display();  // Output: World  

    obj1 = obj2;

    obj1.display();  // Output: World  

    return 0;
}

#endif

#if 0
//匿名对象

#include <iostream>  
#include <string>  
using namespace std;

class Person {
public:
    Person() {
        cout << "Person默认构造" << endl;
    }
    Person(string name) {
        cout << "Person有参构造" << endl;
        m_name = name;
    }
    Person(const Person& per) {
        cout << "Person拷贝构造" << endl;
        m_name = per.m_name;
    }
    ~Person() {
        cout << "析构析构析构" << endl;
    }
    void print_info()const {
        cout << "name: " << m_name << endl;
    }
private:
    string m_name = "huahua";
};

int main() {
    Person per1; // 有名对象 -- 生命周期在当前函数局部域  
    per1.print_info();

    Person().print_info(); // 匿名对象 -- 生命周期在当前行  
    Person const &  p1 = Person("wang");//引用后，匿名对象的生命周期延长至引用销毁（必须是常量引用）
    p1.print_info();
    Person("lili").print_info(); // 匿名对象 -- 生命周期在当前行  
    Person(per1).print_info(); // 匿名对象 -- 生命周期在当前行  

    system("pause");
    return 0;
}

#endif

#if 0
#include <iostream>  
using namespace std;

class OuterClass {
public:
    class InnerClass {
    public:
        void display() {
            cout << "Inside InnerClass" << endl;
        }
    private:
        int a;
    };

    void outerMethod() {
        InnerClass inner;
        inner.display();
        //inner.a = 1;    外部类不可访问内部类私有成员
    }
};

int main() {
    OuterClass outer;
    outer.outerMethod(); // 通过外围类访问内部类的公有方法  
    return 0;
}

#endif

#if 0
#include<iostream>
using namespace std;
class A
{
private:
    static int _k;
    int _h = 1;
public:
    class B // B默认就是A的友元

    {
    public:
        void foo(const A& a)
        {
            cout << _k << endl; //OK
            cout << a._h << endl; //OK
        }
    private:
        static int a;
    };
    void fun()
    {
        //cout << B::a << endl;
        //外部类无法访问内部类的私有成员
    }
    
};
int A::_k = 1;
int main()
{
    
    A::B b;//假如内部类受外部类公有限定符限制，可以这样创建内部类对象
    A aa;
    
    return 0;
}

//#include <iostream>  
//using namespace std;
//class A
//{
//private: static int k;
//       int h;
//public: class B {
//    void foo(const A& a ) 
//    {
//        cout << k << endl;//外部类的静态成员，内部类可以直接访问
//        cout<<a.h<<endl;//外部类的普通成员，内部类需要借助外部类对象访问
//    }
//};
//};
//int A::k = 3;

//#include <iostream>  
//using namespace std;
//
//class OuterClass {
//public:
//    class InnerClass {
//    public:
//        void display() {
//            cout << "Inside InnerClass" << endl;
//        }
//    private:
//        int a;
//    };
//
//    void outerMethod() {
//        InnerClass inner;
//        inner.display();
//        //inner.a = 1;    外部类不可访问内部类私有成员
//    }
//};
//
//int main() {
//    OuterClass outer;
//    outer.outerMethod(); // 通过外围类访问内部类的公有方法  
//    OuterClass::InnerClass a;
//    return 0;
//}
#endif

#if 0

#include<iostream>

using namespace std;

int func1()
{
    return 10;
}

// 不能做参数

//void func2(auto a)
//{}
// 可以做返回值，但是建议谨慎使用

auto func3()
{
    return 3;
}

int main()
{
    int a = 10;
    auto b = a;
    auto c = 'a';
    auto d = func1();
    // 编译报错:rror C3531: “e”: 类型包含“auto”的符号必须具有初始值设定项

    auto e;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    cout << typeid(d).name() << endl;
    int x = 10;
    auto y = &x;
    auto* z = &x;
    auto& m = x;
    cout << typeid(x).name() << endl;
    cout << typeid(y).name() << endl;
    cout << typeid(z).name() << endl;
    auto aa = 1, bb = 2;
    // 编译报错：error C3538: 在声明符列表中，“auto”必须始终推导为同一类型
    //auto cc = 3, dd = 4.0;
    // 
    // 编译报错：error C3318: “auto []”: 数组不能具有其中包含“auto”的元素类型
   // auto array[] = { 4, 5, 6 };
    return 0;
}

#endif

#if 0
#include<iostream>
#include <string>
#include <map>

using namespace std;

int main()
{
    std::map<std::string, std::string> dict = { { "apple", "苹果" },{ "orange",

   "橙子" }, {"pear","梨"} };
    // auto的用武之地

    //std::map<std::string, std::string>::iterator it = dict.begin();

    auto it = dict.begin();
    while (it != dict.end())
    {
        cout << it->first << ":" << it->second << endl;
        ++it;
    }

    return 0;
}

#endif

#if 0
#include <iostream>  
#include <cstring>  

class MyClass {
private:
    char* data;

public:
    // 默认构造函数  
    MyClass(const char* str = "") {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }

    // 拷贝构造函数  
    MyClass(const MyClass& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    // 析构函数  
    ~MyClass() {
        delete[] data;
    }

    // 打印数据  
    void print() const {
        std::cout << data << std::endl;
    }
};

int main() {
    MyClass obj1("Hello");
    MyClass obj2 = obj1; // 调用拷贝构造函数  

    obj1.print(); // 输出: Hello  
    obj2.print(); // 输出: Hello  

    return 0;
}
#endif

#if 1

//#include <stdio.h>
//
//// 全局变量
//int globalVar = 10;
//
//void function() {
//    // 静态变量
//    static int staticVar = 20;
//    printf("globalVar: %d, staticVar: %d\n", globalVar, staticVar);
//}
//
//int main() {
//    function();
//    function();
//    return 0;
//}

//#include <stdio.h>
//#include <stdlib.h>
//
//int main() {
//    int* p = (int*)malloc(10 * sizeof(int));  // 分配10个整数的内存
//    if (p == NULL) {
//        fprintf(stderr, "Memory allocation failed\n");
//        return 1;
//    }
//
//    for (int i = 0; i < 10; i++) {
//        p[i] = i * 10;
//    }
//
//    printf("Array: ");
//    for (int i = 0; i < 10; i++) {
//        printf("%d ", p[i]);
//    }
//    printf("\n");
//
//    free(p);  // 释放内存
//
//    return 0;
//}

//#include <stdio.h>
//#include <stdlib.h>
//
//int main() {
//    int* arr = (int*)malloc(5 * sizeof(int));  // 分配5个整数的内存
//    if (arr == NULL) {
//        fprintf(stderr, "Memory allocation failed\n");
//        return 1;
//    }
//
//    for (int i = 0; i < 5; i++) {
//        arr[i] = i * 10;
//    }
//
//    printf("Initial array: ");
//    for (int i = 0; i < 5; i++) {
//        printf("%d ", arr[i]);
//    }
//    printf("\n");
//
//    // 重新分配内存，扩展数组到10个元素
//    int* tmp = (int*)realloc(arr, 10 * sizeof(int));
//    if (tmp == NULL) {
//        fprintf(stderr, "Memory reallocation failed\n");
//        return 1;
//    }
//    arr = tmp;
//
//    for (int i = 5; i < 10; i++) {
//        arr[i] = i * 10;
//    }
//
//    printf("Extended array: ");
//    for (int i = 0; i < 10; i++) {
//        printf("%d ", arr[i]);
//    }
//    printf("\n");
//
//    free(arr);  // 释放内存
//
//    return 0;
//}

//#include <stdio.h>
//#include <stdlib.h>
//
//void process_data() {
//    int* p = (int*)malloc(10 * sizeof(int));
//    if (p == NULL) {
//        fprintf(stderr, "Memory allocation failed\n");
//        return;
//    }
//
//    // 使用分配的内存
//    for (int i = 0; i < 10; i++) {
//        p[i] = i * 10;
//    }
//
//    // 释放内存
//    free(p);
//}
//
//int main() {
//    process_data();
//    return 0;
//}

//#include <stdio.h>
//#include <stdlib.h>
//
//int main() {
//    int* p = (int*)malloc(10 * sizeof(int));
//    if (p == NULL) {
//        fprintf(stderr, "Memory allocation failed\n");
//        return 1;
//    }
//
//    // 使用分配的内存
//    for (int i = 0; i < 10; i++) {
//        p[i] = i * 10;
//    }
//
//    // 释放内存
//    free(p);
//    p = NULL;  // 将指针设置为 NULL
//
//    return 0;
//}

//#include<iostream>
//template <typename T>
//T max(T a, T b) {
//    return (a > b) ? a : b;
//}
//int main() {
//    int x = 3, y = 4;
//    double a = 1.1, b = 2.2;
//
//    int maxInt = max(x, y);    // T 被推导为 int
//    double maxDouble = max(a, b); // T 被推导为 double
//
//    std::cout << "Max of " << x << " and " << y << " is " << maxInt << std::endl;
//    std::cout << "Max of " << a << " and " << b << " is " << maxDouble << std::endl;
//
//    return 0;
//}

// 在类内定义
template <typename T>
class Stack {
public:
    void push(const T& item) {
        if (top < size - 1) {
            items[++top] = item;
        }
        else {
            std::cout << "Stack overflow" << std::endl;
        }
    }

    T pop() {
        if (top >= 0) {
            return items[top--];
        }
        else {
            std::cout << "Stack underflow" << std::endl;
            return T(); // 返回默认构造的对象
        }
    }

    bool isEmpty() const {
        return top == -1;
    }
};

// 在类外定义
template <typename T>
void Stack<T>::push(const T& item) {
    if (top < size - 1) {
        items[++top] = item;
    }
    else {
        std::cout << "Stack overflow" << std::endl;
    }
}

template <typename T>
T Stack<T>::pop() {
    if (top >= 0) {
        return items[top--];
    }
    else {
        std::cout << "Stack underflow" << std::endl;
        return T(); // 返回默认构造的对象
    }
}

template <typename T>
bool Stack<T>::isEmpty() const {
    return top == -1;
}
#endif